# 1.10 Modelos de Lenguaje de Gran Escala (LLMs) ## Indice 1. [Arquitectura base: Transformer decoder](#1-arquitectura-base-transformer-decoder) 2. [Preentrenamiento a escala](#2-preentrenamiento-a-escala) 3. [Leyes de escala (Scaling Laws)](#3-leyes-de-escala) 4. [Tokenizacion avanzada](#4-tokenizacion-avanzada) 5. [Mejoras arquitectonicas modernas](#5-mejoras-arquitectonicas-modernas) 6. [Ajuste fino supervisado (SFT)](#6-ajuste-fino-supervisado) 7. [RLHF y alineacion](#7-rlhf-y-alineacion) 8. [Inferencia eficiente](#8-inferencia-eficiente) 9. [Adaptacion eficiente en parametros (PEFT)](#9-adaptacion-eficiente-en-parametros) 10. [Capacidades emergentes](#10-capacidades-emergentes) 11. [Evaluacion de LLMs](#11-evaluacion-de-llms) 12. [Referencias](#12-referencias) --- ## 1. Arquitectura Base: Transformer Decoder ### 1.1 Formulacion del modelo de lenguaje autorregresivo Un LLM define una distribucion sobre secuencias de tokens mediante la regla de la cadena: $$p_\theta(\mathbf{x}) = \prod_{t=1}^{T} p_\theta(x_t \mid x_1, \ldots, x_{t-1}) = \prod_{t=1}^{T} p_\theta(x_t \mid x_{ i$) se anulan exactamente: $\exp(-\infty) = 0$. Esto garantiza que la prediccion en la posicion $i$ solo use tokens anteriores. **Motivo del escalado por $\sqrt{d_k}$:** si $q_i, k_i \overset{iid}{\sim} \mathcal{N}(0, 1)$, entonces: $$\text{Var}\left[\mathbf{q}^\top \mathbf{k}\right] = \text{Var}\left[\sum_{i=1}^{d_k} q_i k_i\right] = \sum_{i=1}^{d_k} \mathbb{E}[q_i^2]\mathbb{E}[k_i^2] = d_k$$ Sin escalar, la varianza crece con $d_k$, llevando a la saturacion del softmax y gradientes nulos. Al dividir por $\sqrt{d_k}$, la varianza se normaliza a 1. ### 1.4 Multi-Head Attention Con $h$ cabezas, dimension por cabeza $d_k = d_v = d_{model}/h$: $$\text{head}_i = \text{Attention}(\mathbf{X}\mathbf{W}_i^Q, \mathbf{X}\mathbf{W}_i^K, \mathbf{X}\mathbf{W}_i^V)$$ $$\text{MHA}(\mathbf{X}) = \text{Concat}(\text{head}_1, \ldots, \text{head}_h)\mathbf{W}^O$$ con $\mathbf{W}_i^Q, \mathbf{W}_i^K \in \mathbb{R}^{d_{model} \times d_k}$, $\mathbf{W}_i^V \in \mathbb{R}^{d_{model} \times d_v}$, $\mathbf{W}^O \in \mathbb{R}^{h \cdot d_v \times d_{model}}$. **Parametros totales de MHA:** $4d_{model}^2$ (tres proyecciones de entrada + proyeccion de salida, cada una $d_{model} \times d_{model}$). ### 1.5 Feed-Forward Network $$\text{FFN}(\mathbf{x}) = f(\mathbf{x}\mathbf{W}_1 + \mathbf{b}_1)\mathbf{W}_2 + \mathbf{b}_2$$ con $\mathbf{W}_1 \in \mathbb{R}^{d_{model} \times d_{ff}}$, $d_{ff} = 4 d_{model}$ tipicamente. **Activacion GeLU** (usada en GPT-2/3, BERT): $$\text{GeLU}(x) = x \cdot \Phi(x) \approx 0.5x\left(1 + \tanh\!\left[\sqrt{\frac{2}{\pi}}\left(x + 0.044715x^3\right)\right]\right)$$ **Activacion SwiGLU** (LLaMA, PaLM): $$\text{SwiGLU}(\mathbf{x}, \mathbf{W}, \mathbf{V}) = \text{Swish}_1(\mathbf{x}\mathbf{W}) \odot (\mathbf{x}\mathbf{V})$$ $$\text{Swish}_\beta(x) = x \cdot \sigma(\beta x)$$ SwiGLU usa tres matrices ($\mathbf{W}_1, \mathbf{W}_2, \mathbf{W}_3$) con $d_{ff} = \frac{2}{3} \cdot 4 d_{model}$ para mantener el conteo de parametros. ### 1.6 Layer Normalization $$\text{LN}(\mathbf{x}) = \frac{\mathbf{x} - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \boldsymbol{\gamma} + \boldsymbol{\beta}$$ $$\mu = \frac{1}{d}\sum_{i=1}^d x_i, \quad \sigma^2 = \frac{1}{d}\sum_{i=1}^d (x_i - \mu)^2$$ **RMSNorm** (T5, LLaMA): elimina el centrado, solo escala: $$\text{RMSNorm}(\mathbf{x}) = \frac{\mathbf{x}}{\text{RMS}(\mathbf{x})} \odot \boldsymbol{\gamma}, \quad \text{RMS}(\mathbf{x}) = \sqrt{\frac{1}{d}\sum_{i=1}^d x_i^2 + \epsilon}$$ Mas eficiente computacionalmente y empiricamente equivalente a LN en LLMs. ### 1.7 Weight Tying La matriz de la cabeza de prediccion $\mathbf{W}_{out} \in \mathbb{R}^{|\mathcal{V}| \times d_{model}}$ comparte pesos con la tabla de embeddings $\mathbf{E} \in \mathbb{R}^{|\mathcal{V}| \times d_{model}}$: $$\mathbf{W}_{out} = \mathbf{E}$$ Esto reduce el numero de parametros en $|\mathcal{V}| \cdot d_{model}$ (tipicamente 50K × 4096 ≈ 200M params para modelos grandes) y mejora la generalizacion al forzar consistencia entre la representacion de entrada y salida de cada token. ### 1.8 Conteo de parametros Para un Transformer decoder con $L$ capas, $d_{model}$, $h$ cabezas, $d_{ff} = 4d_{model}$, vocabulario $|\mathcal{V}|$: | Componente | Parametros | |-----------|-----------| | Tabla de embeddings | $|\mathcal{V}| \cdot d_{model}$ | | MHA por capa ($\times L$) | $4 d_{model}^2$ | | FFN por capa ($\times L$) | $2 d_{model} \cdot d_{ff} = 8 d_{model}^2$ | | LN por capa ($\times 2L$) | $2 d_{model}$ | | LN final | $d_{model}$ | | **Total aprox.** | $|\mathcal{V}| d_{model} + 12 L d_{model}^2$ | Para GPT-3 ($L=96$, $d_{model}=12288$, $|\mathcal{V}|=50257$): $\approx 175 \times 10^9$ parametros. --- ## 2. Preentrenamiento a Escala ### 2.1 Objetivo de modelado de lenguaje El objetivo autorregresivo (next-token prediction) maximiza: $$\mathcal{L}_{LM} = \frac{1}{|\mathcal{D}|} \sum_{\mathbf{x} \in \mathcal{D}} \sum_{t=1}^{T} \log p_\theta(x_t \mid x_{ t_{warmup} \end{cases}$$ El warmup evita que los primeros pasos, donde los momentos de Adam no estan calibrados, destruyan la inicializacion. ### 2.4 Gradient Clipping Para evitar la explosion del gradiente: $$\mathbf{g} \leftarrow \begin{cases} \mathbf{g} & \text{si } \|\mathbf{g}\|_2 \leq \tau \\ \dfrac{\tau}{\|\mathbf{g}\|_2} \mathbf{g} & \text{si } \|\mathbf{g}\|_2 > \tau \end{cases}$$ con $\tau = 1.0$ tipicamente. Preserva la direccion del gradiente, solo controla su magnitud. ### 2.5 Procesamiento del corpus **Concatenacion y segmentacion:** el corpus se concatena en una unica secuencia con tokens de separacion de documentos (`<|endoftext|>`) y se divide en chunks de longitud fija $T_{max}$ (contexto del modelo): $$\text{chunks} = \text{split}(\text{concat}(d_1, \langle\text{eos}\rangle, d_2, \langle\text{eos}\rangle, \ldots), T_{max})$$ **Data mixing:** multiples fuentes de datos se mezclan con pesos asignados. Ejemplo aproximado de Llama-3: | Fuente | Proporcion | |--------|-----------| | Common Crawl (web) | ~80% | | Wikipedia / Wikidata | ~5% | | Libros / dominio especifico | ~10% | | Codigo (GitHub) | ~5% | --- ## 3. Leyes de Escala ### 3.1 Ley de potencias de Kaplan et al. (2020) La perdida de test en un LLM sigue una ley de potencias respecto al numero de parametros $N$, tokens de entrenamiento $D$, y compute $C$: $$L(N) = \left(\frac{N_c}{N}\right)^{\alpha_N}, \quad \alpha_N \approx 0.076$$ $$L(D) = \left(\frac{D_c}{D}\right)^{\alpha_D}, \quad \alpha_D \approx 0.095$$ $$L(C) = \left(\frac{C_c}{C}\right)^{\alpha_C}, \quad \alpha_C \approx 0.050$$ donde $N_c$, $D_c$, $C_c$ son constantes de normalizacion. La relacion entre compute, parametros y tokens es: $$C \approx 6ND \quad \text{[FLOPs]}$$ El factor 6 proviene de: $\approx 2ND$ en forward pass (multiplicacion y suma) y $\approx 4ND$ en backward pass. ### 3.2 Ley de Chinchilla (Hoffmann et al., 2022) Kaplan et al. recomendaban escalar $N$ mas agresivamente que $D$ con compute fijo. Hoffmann et al. demostraron que el optimo **computa-fijo** se alcanza cuando: $$N_{opt} \propto C^{0.5}, \quad D_{opt} \propto C^{0.5}$$ Es decir, parametros y tokens deben escalar **proporcionalmente**. La regla empirica de Chinchilla: $$D_{opt} \approx 20 \cdot N$$ Ejemplo: un modelo de 70B parametros se entrena de forma optima con $\approx 1.4T$ tokens. ### 3.3 Perdida conjunta La perdida como funcion de $N$ y $D$ simultaneamente: $$L(N, D) = E + \frac{A}{N^\alpha} + \frac{B}{D^\beta}$$ donde: - $E \approx 1.69$: entropia irreducible del lenguaje natural. - $A, B, \alpha, \beta$: constantes ajustadas empiricamente. - $A/N^\alpha$: sesgo por capacidad finita del modelo. - $B/D^\beta$: sesgo por datos de entrenamiento insuficientes. Con compute $C = 6ND$ fijo, la asignacion optima se obtiene minimizando $L(N, D)$ sujeto a $C = 6ND$: $$\frac{\partial L}{\partial N}\bigg|_{D=C/6N} = 0 \implies \frac{\alpha A}{N^{\alpha+1}} = \frac{\beta B}{D^{\beta+1}}$$ --- ## 4. Tokenizacion Avanzada ### 4.1 Byte-Pair Encoding (BPE) Algoritmo iterativo de construccion del vocabulario: 1. Inicializar con todos los caracteres UTF-8 como simbolos base. 2. Calcular la frecuencia de todos los pares de simbolos consecutivos. 3. Fusionar el par mas frecuente $(a, b) \to ab$ y agregar $ab$ al vocabulario. 4. Repetir hasta alcanzar el tamaño de vocabulario objetivo $|\mathcal{V}|$. **Propiedad clave:** las palabras frecuentes quedan como tokens completos; las raras se segmentan en subpalabras conocidas, eliminando el problema de tokens fuera de vocabulario (OOV). ### 4.2 WordPiece (BERT) Similar a BPE pero el criterio de fusion maximiza la verosimilitud del corpus en lugar de la frecuencia del par: $$\text{score}(a, b) = \frac{f(ab)}{f(a) \cdot f(b)}$$ Fusiona el par cuya ocurrencia conjunta es mas sorprendente dado el producto de sus frecuencias individuales. ### 4.3 SentencePiece Tokeniza directamente sobre texto crudo sin presegmentacion por espacios (necesario para lenguas como chino, japones, tailandes). Modela el espacio como un caracter especial `▁`. Usa BPE o modelos de lenguaje de unigrama como algoritmo subyacente. **Modelo de unigrama:** asigna a cada segmentacion posible $\mathbf{x} = (x_1, \ldots, x_n)$ la probabilidad: $$p(\mathbf{x}) = \prod_{i=1}^{n} p(x_i)$$ y selecciona la segmentacion de mayor probabilidad (Viterbi). ### 4.4 Fertilidad La **fertilidad** de un tokenizador mide cuantos tokens genera por palabra: $$\text{fertility}(\mathcal{V}, \mathcal{D}) = \frac{\text{n tokens}(\mathcal{D})}{\text{n palabras}(\mathcal{D})}$$ Vocabularios mas grandes tienen menor fertilidad (mas palabras completas como tokens) pero mayor tamaño de la tabla de embeddings. --- ## 5. Mejoras Arquitectonicas Modernas ### 5.1 Rotary Positional Embedding (RoPE) RoPE (Su et al., 2021) codifica la posicion rotando los vectores Q y K antes del producto interno. Para un par de dimensiones $(2i, 2i+1)$, la rotacion de un vector en la posicion $m$ es: $$\mathbf{R}_m^{(i)} = \begin{pmatrix} \cos(m\theta_i) & -\sin(m\theta_i) \\ \sin(m\theta_i) & \cos(m\theta_i) \end{pmatrix}, \quad \theta_i = 10000^{-2i/d_k}$$ El producto interno entre query en posicion $m$ y key en posicion $n$ resulta: $$(\mathbf{R}_m \mathbf{q})^\top (\mathbf{R}_n \mathbf{k}) = \mathbf{q}^\top \mathbf{R}_{n-m} \mathbf{k}$$ Es decir, el score de atencion solo depende de la **posicion relativa** $n - m$, no de las posiciones absolutas. Esto da al modelo conciencia de distancias relativas y permite extrapolacion a longitudes no vistas en entrenamiento. ### 5.2 Grouped Query Attention (GQA) En la atencion estandar, cada cabeza tiene sus propias matrices $\mathbf{W}^K$ y $\mathbf{W}^V$. **Multi-Query Attention (MQA):** una sola cabeza de K y V compartida por todas las cabezas de Q. Reduce la memoria del KV-Cache en un factor $h$ pero puede degradar la calidad. **Grouped Query Attention:** $G$ grupos de cabezas Q, cada grupo comparte una cabeza de K y V. Es un compromiso entre MHA y MQA: $$\text{head}_{i,g} = \text{Attention}(\mathbf{Q}_i, \mathbf{K}_g, \mathbf{V}_g), \quad g = \lceil ih/G \rceil$$ Llama-3 70B usa $h=64$ cabezas Q y $G=8$ cabezas KV. **Reduccion de memoria:** el KV-Cache se reduce de $O(h \cdot d_k \cdot T)$ a $O(G \cdot d_k \cdot T)$. ### 5.3 KV-Cache Durante la inferencia autorregresiva, en cada paso $t$ se computan nuevas proyecciones K y V solo para el token nuevo $x_t$. Los K y V de posiciones anteriores se almacenan en cache: $$\mathbf{K}^{(t)} = [\mathbf{K}^{(t-1)}; \mathbf{k}_t], \quad \mathbf{V}^{(t)} = [\mathbf{V}^{(t-1)}; \mathbf{v}_t]$$ **Reduccion de computo:** sin cache, generar $T$ tokens requiere $O(T^2)$ multiplicaciones; con cache, $O(T)$. La memoria aumenta linealmente en $T$. **Tamaño del KV-Cache** para un batch de tamaño $B$, longitud de contexto $T$, $L$ capas, $G$ cabezas KV: $$\text{KV-Cache} = 2 \cdot B \cdot T \cdot L \cdot G \cdot d_k \cdot \text{bytes\_por\_elemento}$$ En float16 (2 bytes), Llama-3 70B con $T=8192$: $\approx 8$ GB solo de KV-Cache. ### 5.4 Flash Attention Rossen et al. (2022) reordenan los computos para evitar materializar la matriz de atencion completa $\mathbf{S} = \mathbf{Q}\mathbf{K}^\top / \sqrt{d_k} \in \mathbb{R}^{T \times T}$ en memoria HBM (High Bandwidth Memory): $$\text{Complejidad estandar: } O(T^2) \text{ en HBM}$$ $$\text{Flash Attention: } O(T^2/M) \text{ accesos HBM}, \quad M = \text{SRAM size}$$ Usa **tiling** (bloques de la matriz) y el **log-sum-exp trick** para calcular el softmax de forma numericamente estable en bloques: $$\text{LSE}(x_1, \ldots, x_n) = \log \sum_{i=1}^n e^{x_i} = c + \log \sum_{i=1}^n e^{x_i - c}, \quad c = \max_i x_i$$ Flash Attention 2/3 es 2-3x mas rapido que la implementacion naive y reduce el uso de memoria de $O(T^2)$ a $O(T)$ (excluyendo Q, K, V). ### 5.5 Extended Context: Ventanas de Atencion y ALiBi **Sparse Attention:** en lugar de atender a todos los $T$ tokens, cada token atiende solo a un subconjunto estructurado (ventana local + atencion global selectiva). Longformer usa una ventana de tamano $w$: $$\text{atencion local: } O(T \cdot w) \text{ en lugar de } O(T^2)$$ **ALiBi (Press et al., 2021):** en lugar de sumar embeddings posicionales, se resta un bias lineal proporcional a la distancia: $$\text{score}_{ij} = \frac{\mathbf{q}_i^\top \mathbf{k}_j}{\sqrt{d_k}} - m_h \cdot |i - j|$$ donde $m_h$ es una pendiente especifica por cabeza. El modelo aprende a penalizar atenciones a larga distancia. Permite extrapolacion a longitudes mayores que las de entrenamiento sin degradacion severa. --- ## 6. Ajuste Fino Supervisado ### 6.1 Instruction Tuning (SFT) Dado un dataset de pares (instruccion, respuesta) $\{(x^{(i)}, y^{(i)})\}$, el ajuste fino minimiza: $$\mathcal{L}_{SFT}(\theta) = -\frac{1}{N} \sum_{i=1}^{N} \sum_{t=1}^{|y^{(i)}|} \log p_\theta(y_t^{(i)} \mid x^{(i)}, y_{<|start_header_id|>system<|end_header_id|> {system_prompt}<|eot_id|> <|start_header_id|>user<|end_header_id|> {user_message}<|eot_id|> <|start_header_id|>assistant<|end_header_id|> {assistant_response}<|eot_id|> ``` ### 6.2 Catastrophic Forgetting El ajuste fino en un dataset pequeno puede degradar las capacidades generales adquiridas en el preentrenamiento. Estrategias de mitigacion: **Elastic Weight Consolidation (EWC):** $$\mathcal{L}_{EWC}(\theta) = \mathcal{L}_{SFT}(\theta) + \frac{\lambda}{2} \sum_i F_i (\theta_i - \theta_i^*)^2$$ donde $F_i$ es la diagonal de la **matriz de informacion de Fisher**: $$F_i = \mathbb{E}_{\mathbf{x} \sim \mathcal{D}_{pre}}\left[\left(\frac{\partial \log p_\theta(x)}{\partial \theta_i}\right)^2\right]$$ Penaliza cambios en parametros importantes para el preentrenamiento, ponderados por su relevancia (estimada por la curvatura del loss). --- ## 7. RLHF y Alineacion ### 7.1 Reward Modeling Dado un conjunto de comparaciones humanas $\{(x, y_w, y_l)\}$ donde $y_w$ es la respuesta preferida y $y_l$ la rechazada, se entrena el modelo de recompensa $r_\phi(x, y)$ con el modelo de **Bradley-Terry**: $$p(y_w \succ y_l \mid x) = \sigma(r_\phi(x, y_w) - r_\phi(x, y_l)) = \frac{\exp(r_\phi(x, y_w))}{\exp(r_\phi(x, y_w)) + \exp(r_\phi(x, y_l))}$$ La perdida de entrenamiento es la log-verosimilitud negativa de las preferencias: $$\mathcal{L}_{RM}(\phi) = -\mathbb{E}_{(x, y_w, y_l) \sim \mathcal{D}_{pref}} \left[\log \sigma(r_\phi(x, y_w) - r_\phi(x, y_l))\right]$$ ### 7.2 PPO para LLMs Proximal Policy Optimization (Schulman et al., 2017) optimiza la politica $\pi_\theta$ maximizando la recompensa con restriccion KL: $$\mathcal{J}_{RLHF}(\theta) = \mathbb{E}_{x \sim \mathcal{D}, y \sim \pi_\theta(y|x)}\left[r_\phi(x, y) - \beta \cdot D_{KL}(\pi_\theta(y \mid x) \| \pi_{ref}(y \mid x))\right]$$ El termino KL desacoplado se estima token por token: $$D_{KL}(\pi_\theta \| \pi_{ref}) = \sum_{t=1}^{T} \log \frac{\pi_\theta(y_t \mid x, y_{ k$ para reducir la varianza del estimador. ### 11.4 LLM-as-Judge Usar GPT-4 u otro LLM potente para evaluar la calidad de respuestas. La correlacion con juicios humanos es alta ($\rho > 0.8$) para tareas de respuesta abierta donde la evaluacion automatica clasica falla. **Sesgos conocidos del LLM-judge:** - **Sesgo de posicion:** prefiere respuestas en la primera posicion. - **Sesgo de verbosidad:** prefiere respuestas mas largas. - **Sesgo de auto-preferencia:** GPT-4 prefiere respuestas estilo GPT-4. Mitigacion: evaluar en ambos ordenes y promediar; normalizar por longitud. ### 11.5 RLHF Reward Model como proxy de alineacion El **reward hacking** ocurre cuando la politica maximiza la recompensa del RM sin mejorar la calidad real: $$r_{human}(\pi) \not\approx r_{RM}(\pi) \quad \text{si } \pi \text{ se aleja mucho de } \pi_{SFT}$$ El termino KL en RLHF actua como regularizador para evitar este problema. El coeficiente $\beta$ controla el compromiso entre maximizar recompensa y mantenerse cerca de la politica de referencia: $$\pi^* = \arg\max_\pi \mathbb{E}_y[r(x,y)] - \beta \cdot D_{KL}(\pi \| \pi_{ref})$$ --- ## 12. Referencias - Vaswani, A., et al. (2017). Attention is all you need. *NeurIPS 2017*. - Brown, T., et al. (2020). Language models are few-shot learners. *NeurIPS 2020*. - Kaplan, J., et al. (2020). Scaling laws for neural language models. *arXiv:2001.08361*. - Hoffmann, J., et al. (2022). Training compute-optimal large language models (Chinchilla). *NeurIPS 2022*. - Su, J., et al. (2021). RoFormer: Enhanced transformer with rotary position embedding. *arXiv:2104.09864*. - Ainslie, J., et al. (2023). GQA: Training generalized multi-query transformer models. *EMNLP 2023*. - Dao, T., et al. (2022). FlashAttention: Fast and memory-efficient exact attention. *NeurIPS 2022*. - Ouyang, L., et al. (2022). Training language models to follow instructions with human feedback. *NeurIPS 2022*. - Bai, Y., et al. (2022). Constitutional AI: Harmlessness from AI feedback. *arXiv:2212.08073*. - Rafailov, R., et al. (2023). Direct preference optimization. *NeurIPS 2023*. - Hu, E., et al. (2021). LoRA: Low-rank adaptation of large language models. *ICLR 2022*. - Dettmers, T., et al. (2023). QLoRA: Efficient finetuning of quantized LLMs. *NeurIPS 2023*. - Frantar, E., et al. (2022). GPTQ: Accurate post-training quantization for generative pre-trained transformers. *arXiv:2210.17323*. - Wei, J., et al. (2022). Chain-of-thought prompting elicits reasoning in large language models. *NeurIPS 2022*. - Wei, J., et al. (2022). Emergent abilities of large language models. *TMLR 2022*. - Lewis, P., et al. (2020). Retrieval-augmented generation for knowledge-intensive NLP tasks. *NeurIPS 2020*. - Leviathan, Y., et al. (2023). Fast inference from transformers via speculative decoding. *ICML 2023*. - Press, O., et al. (2021). Train short, test long: Attention with linear biases (ALiBi). *ICLR 2022*. - Schulman, J., et al. (2017). Proximal policy optimization algorithms. *arXiv:1707.06347*. - Sennrich, R., et al. (2016). Neural machine translation of rare words with subword units. *ACL 2016*. - Lester, B., et al. (2021). The power of scale for parameter-efficient prompt tuning. *EMNLP 2021*. - Li, X.L., & Liang, P. (2021). Prefix-tuning: Optimizing continuous prompts for generation. *ACL 2021*. ---